#ifndef __SURFACE
#define __SURFACE
#include <vector>
#include <string>
#include "sommet.hpp"
#include "face.hpp"
#include <fstream>
#include <iostream>
#include <algorithm>




class Surface
{
	private:
		std::vector<Sommet> sommets;//tableau des sommets de la surface
		std::vector<Face> faces;//tableau des faces de la surface
		
	public:
		Surface(){};//constructeur par defaut
		Surface(std::vector<Sommet> s, std::vector<Face> f):sommets(s),faces(f){};//constructeur
		~Surface()//destructeur
		{
			sommets.clear();
			faces.clear();
		};
		
		std::vector<Sommet> getSommets();//accesseur du tableau de sommets
		std::vector<Face> getFaces();//accesseur du tableau de faces
		
		void ajoutSommet(Sommet s);//fonction d'ajout d'un sommet
		void ajoutFace(Face f);//fonction d'ajout d'une face
		
		void chargementOFF(std::string nomFichier);//chargement d'une structure à partir d'un fichier off
		void ecritureOFF(std::string nomFichier);//sauvegarde d'une structure dans un fichier off
		
		template<typename T>
		class Iter//iterateur
		{
			private:
				std::vector<T>* vec;
				int index;
				
			public:
			Iter(){};
			Iter(std::vector<T>* v):vec(v), index(0){}
			Iter(std::vector<T>* v,int i):vec(v), index(i){}
			~Iter(){}
			
			//surchage de l'operateur ++
			void operator++();
			void operator++(int=0);
			//surchage de l'operateur ==
			bool operator==(const Iter<T>& is);
			//surchage de l'operateur !=
			bool operator!=(const Iter<T>& is);
			//surchage de l'operateur *
			T& operator*();
			
		};
		
		//permet de se positionner au debut du vecteur de faces
		Iter<Face> beginFace()
		{
			return Iter<Face>(&faces);
		}

		//permet de se positionner à la fin du vecteur de faces
		Iter<Face> endFace()
		{
			return Iter<Face>(&faces, faces.size());
		}
		
		//permet de se positionner au debut du vecteur de sommets
		Iter<Sommet> beginSommet()
		{
			return Iter<Sommet>(&sommets);
		}
		
		//permet de se positionner à la fin du vecteur de sommets
		Iter<Sommet> endSommet()
		{
			return Iter<Sommet>(&sommets, sommets.size());
		}
		
};



template<typename T>
void Surface::Iter<T>::operator++()
{
	index++;
}

template<typename T>
void Surface::Iter<T>::operator++(int i)
{
	index++;
}

template<typename T>
bool Surface::Iter<T>::operator==(const Iter<T>& is)
{
	if(vec==is.vec && index==is.index)
	{
		return true;
	}
	return false;
}

template<typename T>
bool Surface::Iter<T>::operator!=(const Iter<T>& is)
{
	if(vec!=is.vec || index!=is.index)
	{
		return true;
	}
	return false;
}

template<typename T>
T& Surface::Iter<T>::operator*()
{
	return vec->at(index);
}

#endif
